#include<bits/stdc++.h>
using namespace std;

#define INF 100000000
struct bpnode{
  static const int t=10;  //B树最小度数
  int n;  //节点关键词个数
  int key[2*bpnode::t-1];  //关键字
  int c[2*bpnode::t];  //子女
  int next,prev;
  int siz;
  bool leaf;
}node[10000];
int root; //全局的根
int all=0; //用来分配bpnode
int idx=0; //b+tree's element index

int find(int r,int k){
  int i=node[r].n-1;
  while(i>=0&&node[r].key[i]>k)--i;
  if(node[r].leaf){
    if(i<0||node[r].key[i]!=k)return 0;
    else return node[r].c[i];
  }else return find(node[r].c[i+1],k);
}
void pushup(int r){
  int res=0;
  if(node[r].leaf){
    for(int i=0;i<node[r].n;i++)
      res+=node[r].c[i];
  }else{
    for(int i=0;i<=node[r].n;i++)
      res+=node[node[r].c[i]].siz;
  }
  node[r].siz=res;
}
void split_child(int r,int x){
	int c=node[r].c[x];
	int w=++all,ns=bpnode::t-1;
	for(int i=node[r].n;i>x;i--)
    node[r].key[i]=node[r].key[i-1];
	++node[r].n;
	for(int i=node[r].n;i>x;i--)
    node[r].c[i]=node[r].c[i-1];
	node[r].key[x]=node[c].key[node[c].n/2];
	node[r].c[x+1]=w;
	if(node[c].leaf){
		for(int i=0;i<ns;i++)
      node[w].key[i]=node[c].key[ns+i];
		for(int i=0;i<ns;i++)node[w].c[i]=node[c].c[ns+i];
		//node[w].c[2*ns+1]=node[c].c[2*ns+1];
		//node[c].c[2*ns+1]=w;
    if(node[c].next)node[node[c].next].prev=w;
    node[w].next=node[c].next;
    node[w].prev=c;
    node[c].next=w;
		node[w].leaf=true;
	}else{
		for(int i=0;i<ns;i++)
      node[w].key[i]=node[c].key[ns+1+i];
		for(int i=0;i<=ns;i++)
      node[w].c[i]=node[c].c[ns+1+i];
		//node[w].leaf=false;
	}
	node[w].n=ns;
	node[c].n=ns;
  pushup(w);
  pushup(c);
}
bool inline needsplit(int r){
	return node[r].n==bpnode::t*2-1||(node[r].leaf&&node[r].n==bpnode::t*2-2);
}
void ins_nonfull(int r,int k){
	int i=node[r].n-1;
  while(i>=0&&k<node[r].key[i])--i;
	if(node[r].leaf==true){
    if(i>=0&&node[r].key[i]==k)++node[r].c[i];
    else{
      for(int j=node[r].n;j>i+1;j--){
        node[r].key[j]=node[r].key[j-1];
        node[r].c[j]=node[r].c[j-1];
      }
      node[r].c[i+1]=1;
      node[r].key[i+1]=k;
      node[r].n+=1;
    }
	}else{
		++i;
		if(needsplit(node[r].c[i])){
			split_child(r,i);
			if(k>=node[r].key[i])++i;
		}
    ins_nonfull(node[r].c[i],k);
	}
  pushup(r);
}
void ins(int x){
	int r=root,s;
	if(needsplit(r)){
		//root is full
		s=++all;
		root=s;
		node[s].leaf=false;
		node[s].c[0]=r;
		split_child(s,0);
		ins_nonfull(root,x);
	}else ins_nonfull(root,x);
}
int pre(int r,int k){
  int i=node[r].n-1;
  while(i>=0&&node[r].key[i]>=k)--i;
  if(node[r].leaf==false)return pre(node[r].c[i+1],k);
  else if(i==-1){
    r=node[r].prev;
    return node[r].key[node[r].n-1];
  }else return node[r].key[i];
}
int nxt(int r,int k){
  int i=0;
  while(i<node[r].n&&node[r].key[i]<=k)++i;
  if(node[r].leaf==false)return nxt(node[r].c[i],k);
  else if(i==node[r].n){
    r=node[r].next;
    return node[r].key[0];
  }else return node[r].key[i];
}

#define LEFT 0
#define RIGHT 1
void roll_child(int x,int k,int dir){
  //assert(node[x].leaf==false);
  int l=node[x].c[k],r=node[x].c[k+1];
  if(dir==LEFT){
    //assert(node[l].n==bpnode::t-1&&node[r].n>=bpnode::t);
    if(node[l].leaf){
      node[l].key[node[l].n++]=node[r].key[0];
      node[l].c[node[l].n-1]=node[r].c[0];
      node[x].key[k]=node[r].key[1];
    }else{
      node[l].key[node[l].n++]=node[x].key[k];
      node[l].c[node[l].n]=node[r].c[0];
      node[x].key[k]=node[r].key[0];
    }
    for(int i=0;i+1<node[r].n;i++)
      node[r].key[i]=node[r].key[i+1];
    for(int i=0;i<node[r].n;i++)
      node[r].c[i]=node[r].c[i+1];
    node[r].n-=1;
  }else{
    //assert(node[r].n==bpnode::t-1&&node[l].n>=bpnode::t);
    for(int i=node[r].n;i>=1;i--)
      node[r].key[i]=node[r].key[i-1];
    for(int i=node[r].n+1;i>=1;i--)
      node[r].c[i]=node[r].c[i-1];
    if(node[l].leaf){
      node[r].key[0]=node[x].key[k]=node[l].key[node[l].n-1];
      node[r].c[0]=node[l].c[node[l].n-1];
    }else{
      node[r].key[0]=node[x].key[k];
      node[r].c[0]=node[l].c[node[l].n];
      node[x].key[k]=node[l].key[node[l].n-1];
    }
    node[l].n-=1;
    node[r].n+=1;
  }
  pushup(r);
  pushup(l);
}
void merge_child(int r,int x){
  int l,h,k;
  //assert(node[r].leaf==false);
  l=node[r].c[x];h=node[r].c[x+1];
  k=node[r].key[x];
  //assert(node[l].n==bpnode::t-1);
  //assert(node[h].n==bpnode::t-1);
  for(int j=x;j+1<node[r].n;j++){
    node[r].key[j]=node[r].key[j+1];
    node[r].c[j+1]=node[r].c[j+2];
  }
  node[r].n-=1;
  if(node[l].leaf==false){
    node[l].key[node[l].n++]=k;
    for(int j=0;j<node[h].n;j++)
      node[l].key[node[l].n+j]=node[h].key[j];
    for(int j=0;j<=node[h].n;j++)
      node[l].c[node[l].n+j]=node[h].c[j];
  }else{
    for(int j=0;j<node[h].n;j++){
      node[l].key[node[l].n+j]=node[h].key[j];
      node[l].c[node[l].n+j]=node[h].c[j];
      //node[l].c[2*bpnode::t-1]=node[h].c[2*bpnode::t-1];
      if(node[h].next)node[node[h].next].prev=l;
      node[l].next=node[h].next;
    }
  }
  node[l].n+=node[h].n;
  pushup(l);
}
void del_one(int r,int k){
  int i=node[r].n-1;
  while(i>=0&&node[r].key[i]>k)--i;
  if(i>=0&&node[r].key[i]==k&&node[r].leaf){
    if(node[r].c[i]>1)--node[r].c[i];
    else{
      --node[r].n;
      for(;i<node[r].n;i++){
        node[r].key[i]=node[r].key[i+1];
        node[r].c[i]=node[r].c[i+1];
      }
    }
  }else{
    ++i;
    if(node[node[r].c[i]].n<bpnode::t){
      int x=i-1;
      if(x<0||node[node[r].c[x]].n<bpnode::t)x=i+1;
      if(x<=node[r].n&&node[node[r].c[x]].n>=bpnode::t){
        if(x<i)roll_child(r,x,RIGHT);
        else roll_child(r,i,LEFT);
      }else{
        if(i!=node[r].n)merge_child(r,i);
        else merge_child(r,--i);
      }
    }
    del_one(node[r].c[i],k);
  }
  //pushup(r);
  node[r].siz-=1;
}
void del(int k){
  if(find(root,k)==0)return;
  del_one(root,k);
  if(node[root].n==0)root=node[root].c[0];
}
int rnk(int r,int k){
  int res=0;
  int i;
  for(i=0;i<node[r].n&&node[r].key[i]<k;i++){
    if(node[r].leaf)res+=node[r].c[i];
    else res+=node[node[r].c[i]].siz;
  }
  if(node[r].leaf==false)res+=rnk(node[r].c[i],k);
  return res;
}
int kth(int r,int k){
  if(node[r].leaf){
    for(int i=0;i<node[r].n;i++){
      if(node[r].c[i]>=k)return node[r].key[i];
      k-=node[r].c[i];
    }
    //assert(0);
  }
  for(int i=0;i<=node[r].n;i++){
    if(node[node[r].c[i]].siz>=k)
      return kth(node[r].c[i],k);
    k-=node[node[r].c[i]].siz;
  }
  //assert(0);
  return 0;
}
int main(){
  #ifdef BUG
  freopen("a.in","r",stdin);
  #endif
  memset(node,0,sizeof node);
  root=++all; //创建根节点
  node[root].leaf=true;
	idx=root;
  ins(INF);
  ins(-INF);
  int t,op,a;
  scanf("%d",&t);
  while(t--){
    scanf("%d%d",&op,&a);
    if(op==1)ins(a);
    else if(op==2)del(a);
    else if(op==3)printf("%d\n",rnk(root,a));
    else if(op==4)printf("%d\n",kth(root,a+1));
    else if(op==5)printf("%d\n",pre(root,a));
    else if(op==6)printf("%d\n",nxt(root,a));
  }
}
